// cf-327e
// 题意：给定n(<=24)个数，现在问对于这些数的排列，若前缀和中有给定的k(<=2)
//       个数，则是个不好排列，问有多少种好排列。
//
// 题解：如果k=0, 那么答案就是n!，如果k=1，那我们算有多少排列有一个前缀和
//       等于给定的数，我们可以枚举2^n来枚举那个前缀和，假如说枚举的2^n里
//       面有k个数，那么坏排列个数就是k!*(n-k)!，最后答案一减就行。但是这
//       样复杂度太高，我们用整体二分的思想。
//       枚举左边1..n/2的2^(n/2)的状态，算出所有状态的和sum以及数的个数tot,
//       然后枚举右边2^(n/2)，对于每个枚举到的状态，我们枚举左边元素个数k，
//       因为我们知道最终的和是那个给定的数u，所以就看(u-sum, k)在不在左边
//       的统计状态里，如果在就算上。
//
//       现在对于k=2，有两个数u1, u2，根据容斥原理，坏序列的个数就是
//         前缀和有u1的个数+前缀和有u2的个数-前缀和既有u1又有u2的个数。
//       前面两个就是k=1的情况，最后一个也是类似的方法。设u1<=u2，那么序列
//       就被分成了三段，第一段的和等于u1, 第二段的和等于u2-u1，我们可以令
//       3^n来枚举所有状态，1表示该数在第1段，2表示该数在第二段，0表示在第
//       三段，假如说枚举到第1段个数tot1, 第二段个数tot2, 那么坏序列的个数
//       就是tot1!*tot2!*(n-tot1-tot2)!，但是这样直接枚举还是要超时。
//       我们还是分成两半，先统计左边一半(sum1, tot1, sum2, tot2)，然后
//       枚举右边状态，因为已经知道要求的和是u1, u2-u1，只需要枚举左边两
//       段的个数i, j，然后检查(u1-sum1, i, u2-u1-sum2, j)在不在，如果有
//       就算上答案。
//
//       这题加上std::ios::sync_with_stdio(false)就没超时，当然可以加几个
//       优化，比如当前的和比目标和u还大是就跳过。
//
// run: time -p $exec < input
#include <iostream>
#include <functional>
#include <algorithm>
#include <unordered_map>

int constexpr maxn = 28;
int constexpr maxm = maxn / 2;
long long  constexpr mo = 1000000007;
long long fact[maxn];
long long pow3[maxm];
long long a[maxn];
long long bad[3];
int n, k;

void init_fact()
{
	fact[0] = 1;
	for (int i = 1; i < maxn; i++)
		fact[i] = (fact[i - 1] * i) % mo;
}

void init_pow3()
{
	pow3[0] = 1;
	for (int i = 1; i < maxm; i++)
		pow3[i] = pow3[i - 1] * 3;
}

using pair_type = std::pair<long long, long long>;
using key_type = pair_type;
struct key_hash
{
	std::size_t operator()(key_type const & key) const
	{
		return std::hash<long long>()(key.first) ^
				(std::hash<long long>()(key.second) << 4);
	}
};
struct key_equal
{
	bool operator()(key_type const & k1, key_type const & k2) const
	{
		return k1 == k2;
	}
};

long long calc(int u)
{
	int lhalf = n / 2;
	int rhalf = n - lhalf;
	// important opt2
	std::unordered_map<key_type, long long, key_hash, key_equal> right;

	for (int i = 0; i < (1 << rhalf); i++) {
		long long sum = 0, tot = 0;
		for (int j = 0; j < rhalf; j++)
			if ((i >> j) & 1) {
				sum += a[j + lhalf];
				tot++;
			}
		right[{sum, tot}]++;
	}

	long long ret = 0;
	for (int i = 0; i < (1 << lhalf); i++) {
		long long sum = 0, tot = 0;
		for (int j = 0; j < lhalf; j++)
			if ((i >> j) & 1) {
				sum += a[j];
				tot++;
			}
		if (sum > u) continue; // important opt1
		for (int j = 0; j + tot <= n && j <= rhalf; j++) {
			auto tmp = right[{u - sum, j}];
			if (tmp) {
				long long ti = (fact[tot + j] * fact[n - tot - j]) % mo;
				ret = (ret + (tmp * ti) % mo) % mo;
			}
		}
	}
	return ret;
}

long long calc2(int u1, int u2)
{
	u2 -= u1;
	int lhalf = n / 2;
	int rhalf = n - lhalf;
	// important opt2
	std::unordered_map<key_type, std::unordered_map<key_type, long long, key_hash, key_equal>,
						key_hash, key_equal> right;
	for (int i = 0; i < pow3[rhalf]; i++) {
		long long sum1 = 0, tot1 = 0, sum2 = 0, tot2 = 0;
		for (int j = 0, t = i; t; j++, t /= 3) {
			if (t % 3 == 1) {
				sum1 += a[j + lhalf];
				tot1++;
			} else if (t % 3 == 2) {
				sum2 += a[j + lhalf];
				tot2++;
			}
		}
		right[{sum1, tot1}][{sum2, tot2}]++;
	}

	long long ret = 0;
	for (int i = 0; i < pow3[lhalf]; i++) {
		long long sum1 = 0, tot1 = 0, sum2 = 0, tot2 = 0;
		for (int j = 0, t = i; t; j++, t /= 3) {
			if (t % 3 == 1) {
				sum1 += a[j];
				tot1++;
			} else if (t % 3 == 2) {
				sum2 += a[j];
				tot2++;
			}
		}
		if (sum1 > u1 || sum2 > u2) continue; // important opt1
		for (int j = 0; j + tot1 + tot2 <= n && j <= rhalf; j++) {
			if (right.find({u1 - sum1, j}) == right.end()) continue;
			for (int k = 0; k + j + tot1 + tot2 <= n && k <= rhalf; k++) {
				auto tmp = right[{u1 - sum1, j}][{u2 - sum2, k}];
				if (tmp) {
					long long ti = (((fact[tot1 + j] * fact[tot2 + k]) % mo) * fact[n - tot1 - tot2 - j - k]) % mo;
					ret = (ret + (tmp * ti)) % mo;
				}
			}
		}
	}
	return ret;
}

int main()
{
	std::ios::sync_with_stdio(false); // important opt3
	init_fact();
	init_pow3();
	std::cin >> n;
	for (int i = 0; i < n; i++)
		std::cin >> a[i];
	std::cin >> k;
	for (int i = 0; i < k; i++)
		std::cin >> bad[i];
	if (k == 2 && bad[0] > bad[1]) std::swap(bad[0], bad[1]);

	if (!k) {
		std::cout << fact[n] << '\n';
	} else if (k == 1) {
		long long ans = fact[n] - calc(bad[0]);
		ans = ((ans % mo) + mo) % mo;
		std::cout << ans << '\n';
	} else {
		long long ans = fact[n] - calc(bad[0]) - calc(bad[1]) + calc2(bad[0], bad[1]);
		ans = ((ans % mo) + mo) % mo;
		std::cout << ans << '\n';
	}
}

